Arquitecturas de Memoria Profunda

1. La Dimensión Temporal en IA

• El Paradigma Estático: Las redes feedforward tradicionales asumen independencia entre muestras (ej. clasificación de imágenes estáticas).
• La Realidad Dinámica: El mundo físico y cognitivo es secuencial (lenguaje, audio, señales biológicas, finanzas).
• La Necesidad de Memoria: Se requiere una arquitectura capaz de mantener un “estado” o contexto histórico para interpretar el presente.

2. Redes Neuronales Recurrentes (RNN)

Concepto Fundamental

La RNN rompe la estructura acíclica. Al “desenrollar” la red en el tiempo, procesa la secuencia paso a paso compartiendo los mismos pesos (\(W\)).

El Problema del Gradiente

Entrenamiento mediante Backpropagation Through Time (BPTT).

La derivada del error respecto a los pesos recurrentes implica un producto continuo de matrices Jacobianas:

\[ \frac{\partial h_t}{\partial h_k} = \prod_{j=k+1}^t \text{diag}(\sigma'(z_j)) W_{hh} \]

3. Long Short-Term Memory (LSTM)

Ingeniería de la Persistencia

Diseñada para mitigar el desvanecimiento del gradiente introduciendo una Celda de Memoria (\(C_t\)) separada del estado oculto.

La neurona LSTM

Tomada de codificando bits

Anatomía de la LSTM (1/2)

El flujo es regulado por Compuertas Sigmoidales (\(\sigma \in [0, 1]\)):

Anatomía de la LSTM (2/2)

Actualización y Salida

3. Actualización de Celda (\(C_t\))

Combinación lineal crítica. Aquí ocurre la magia de la persistencia. \[C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t\]

4. Generación de Salida (\(h_t\))

Filtrado de la memoria para el uso inmediato. \[o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)\] \[h_t = o_t \odot \tanh(C_t)\]

4. Gated Recurrent Units (GRU)

Eficiencia y Simplificación

Propuesta para reducir la complejidad computacional de la LSTM sin sacrificar rendimiento.

• Fusión de Estados: No hay celda \(C_t\) separada. Solo existe \(h_t\).
• Reducción de Compuertas: Solo dos compuertas (Update y Reset).

Dinámica de la GRU

Comparativa Técnica

5. Implementación en PyTorch

Estructura modular agnóstica a la arquitectura (“Many-to-One”).

import torch.nn as nn

class ClasificadorRecurrente(nn.Module):
    def __init__(self, tipo_rnn, input_size, hidden_size, num_classes):
        super().__init__()

        # Selección Dinámica de Arquitectura
        if tipo_rnn == 'LSTM':
            self.rnn = nn.LSTM(input_size, hidden_size, batch_first=True)
        elif tipo_rnn == 'GRU':
            self.rnn = nn.GRU(input_size, hidden_size, batch_first=True)
        else:
            self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)

        self.fc = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        # x shape: (Batch, Seq_Len, Features)

        # Propagación
        if isinstance(self.rnn, nn.LSTM):
            out, (hn, cn) = self.rnn(x) # LSTM devuelve tupla
        else:
            out, hn = self.rnn(x)       # GRU/RNN devuelven tensor

        # Clasificación basada en el último paso de tiempo
        last_step = out[:, -1, :]
        return self.fc(last_step)

Conclusión

La elección arquitectónica depende del balance entre capacidad de memoria y restricciones de latencia/hardware.